package top.hmtools.io;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Stack;

import top.hmtools.base.StringTools;

/**
* General filename and filepath manipulation utilities.
* <p>
* When dealing with filenames you can hit problems when moving from a Windows
* based development machine to a Unix based production machine.
* This class aims to help avoid those problems.
* <p>
* <b>NOTE</b>: You may be able to avoid using this class entirely simply by
* using JDK {@link java.io.File File} objects and the two argument constructor
* {@link java.io.File#File(java.io.File, java.lang.String) File(File,String)}.
* <p>
* Most methods on this class are designed to work the same on both Unix and Windows.
* Those that don't include 'System', 'Unix' or 'Windows' in their name.
* <p>
* Most methods recognise both separators (forward and back), and both
* sets of prefixes. See the javadoc of each method for details.
* <p>
* This class defines six components within a filename
* (example C:\dev\project\file.txt):
* <ul>
* <li>the prefix - C:\</li>
* <li>the path - dev\project\</li>
* <li>the full path - C:\dev\project\</li>
* <li>the name - file.txt</li>
* <li>the base name - file</li>
* <li>the extension - txt</li>
* </ul>
* Note that this class works best if directory filenames end with a separator.
* If you omit the last separator, it is impossible to determine if the filename
* corresponds to a file or a directory. As a result, we have chosen to say
* it corresponds to a file.
* <p>
* This class only supports Unix and Windows style names.
* Prefixes are matched as follows:

* Both prefix styles are matched always, irrespective of the machine that you are
* currently running on.
* <p>
* Origin of code: Excalibur, Alexandria, Tomcat, Commons-Utils.
*
* @version $Id: FilenameUtils.java 1307462 2012-03-30 15:13:11Z ggregory $
* @since 1.1
*/
/**
 * 操作文件名相关工具
 * <p>
* (例子 C:\dev\project\file.txt):
* <ul>
* <li>the prefix - C:\</li>
* <li>the path - dev\project\</li>
* <li>the full path - C:\dev\project\</li>
* <li>the name - file.txt</li>
* <li>the base name - file</li>
* <li>the extension - txt</li>
* </ul>
 * @author Jianghaibo
 *
 */

public class FileNameTools {

   /**
    * 扩展名与文件名隔离的标点字符
    * The extension separator character.
    * @since 1.4
    */
   public static final char EXTENSION_SEPARATOR = '.';

   /**
    * 扩展名与文件名隔离的标点字符串
    * The extension separator String.
    * @since 1.4
    */
   public static final String EXTENSION_SEPARATOR_STR = Character.toString(EXTENSION_SEPARATOR);

   /**
    * unix系统下的路径分隔符
    * The Unix separator character.
    */
   private static final char UNIX_SEPARATOR = '/';

   /**
    *Windows系统下的路径分隔符
    * The Windows separator character.
    */
   private static final char WINDOWS_SEPARATOR = '\\';

   /**
    * 当前操作系统的文件路径分隔符
    * The system separator character.
    */
   private static final char SYSTEM_SEPARATOR = File.separatorChar;

   /**
    * 其它文件路径分隔符（不是Windows的就是Unix的）
    * The separator character that is the opposite of the system separator.
    */
   private static final char OTHER_SEPARATOR;
   static {
       if (isSystemWindows()) {
           OTHER_SEPARATOR = UNIX_SEPARATOR;
       } else {
           OTHER_SEPARATOR = WINDOWS_SEPARATOR;
       }
   }

   /**
    * Instances should NOT be constructed in standard programming.
    */
   public FileNameTools() {
       super();
   }

   //-----------------------------------------------------------------------
   /**
    * 是否是Windows操作系统的文件路径分隔符
    * Determines if Windows file system is in use.
    * 
    * @return true if the system is Windows
    */
   static boolean isSystemWindows() {
       return SYSTEM_SEPARATOR == WINDOWS_SEPARATOR;
   }

   //-----------------------------------------------------------------------
   /**
    * 是否是文件路径分隔符
    * Checks if the character is a separator.
    * 
    * @param ch  the character to check
    * @return true if it is a separator character
    */
   private static boolean isSeparator(char ch) {
       return ch == UNIX_SEPARATOR || ch == WINDOWS_SEPARATOR;
   }

   //-----------------------------------------------------------------------
   /**
    * Normalizes a path, removing double and single dot path steps.
    * <p>
    * This method normalizes a path to a standard format.
    * The input may contain separators in either Unix or Windows format.
    * The output will contain separators in the format of the system.
    * <p>
    * A trailing slash will be retained.
    * A double slash will be merged to a single slash (but UNC names are handled).
    * A single dot path segment will be removed.
    * A double dot will cause that path segment and the one before to be removed.
    * If the double dot has no parent path segment to work with, {@code null}
    * is returned.
    * <p>
    * The output will be the same on both Unix and Windows except
    * for the separator character.
    * <pre>
    * /foo//               -->   /foo/
    * /foo/./              -->   /foo/
    * /foo/../bar          -->   /bar
    * /foo/../bar/         -->   /bar/
    * /foo/../bar/../baz   -->   /baz
    * //foo//./bar         -->   /foo/bar
    * /../                 -->   null
    * ../foo               -->   null
    * foo/bar/..           -->   foo/
    * foo/../../bar        -->   null
    * foo/../bar           -->   bar
    * //server/foo/../bar  -->   //server/bar
    * //server/../bar      -->   null
    * C:\foo\..\bar        -->   C:\bar
    * C:\..\bar            -->   null
    * ~/foo/../bar/        -->   ~/bar/
    * ~/../bar             -->   null
    * </pre>
    * (Note the file separator returned will be correct for Windows/Unix)
    *
    * @param filename  the filename to normalize, null returns null
    * @return the normalized filename, or null if invalid
    */
   public static String normalize(String filename) {
       return doNormalize(filename, SYSTEM_SEPARATOR, true);
   }
   /**
    * Normalizes a path, removing double and single dot path steps.
    * <p>
    * This method normalizes a path to a standard format.
    * The input may contain separators in either Unix or Windows format.
    * The output will contain separators in the format specified.
    * <p>
    * A trailing slash will be retained.
    * A double slash will be merged to a single slash (but UNC names are handled).
    * A single dot path segment will be removed.
    * A double dot will cause that path segment and the one before to be removed.
    * If the double dot has no parent path segment to work with, {@code null}
    * is returned.
    * <p>
    * The output will be the same on both Unix and Windows except
    * for the separator character.
    * <pre>
    * /foo//               -->   /foo/
    * /foo/./              -->   /foo/
    * /foo/../bar          -->   /bar
    * /foo/../bar/         -->   /bar/
    * /foo/../bar/../baz   -->   /baz
    * //foo//./bar         -->   /foo/bar
    * /../                 -->   null
    * ../foo               -->   null
    * foo/bar/..           -->   foo/
    * foo/../../bar        -->   null
    * foo/../bar           -->   bar
    * //server/foo/../bar  -->   //server/bar
    * //server/../bar      -->   null
    * C:\foo\..\bar        -->   C:\bar
    * C:\..\bar            -->   null
    * ~/foo/../bar/        -->   ~/bar/
    * ~/../bar             -->   null
    * </pre>
    * The output will be the same on both Unix and Windows including
    * the separator character.
    *
    * @param filename  the filename to normalize, null returns null
    * @param unixSeparator {@code true} if a unix separator should
    * be used or {@code false} if a windows separator should be used.
    * @return the normalized filename, or null if invalid
    * @since 2.0
    */
   public static String normalize(String filename, boolean unixSeparator) {
       char separator = unixSeparator ? UNIX_SEPARATOR : WINDOWS_SEPARATOR;
       return doNormalize(filename, separator, true);
   }

   //-----------------------------------------------------------------------
   /**
    * 整理文件路径，使其“标准”化。比如去除重复多余的路径分隔符
    * Normalizes a path, removing double and single dot path steps,
    * and removing any final directory separator.
    * <p>
    * This method normalizes a path to a standard format.
    * The input may contain separators in either Unix or Windows format.
    * The output will contain separators in the format of the system.
    * <p>
    * A trailing slash will be removed.
    * A double slash will be merged to a single slash (but UNC names are handled).
    * A single dot path segment will be removed.
    * A double dot will cause that path segment and the one before to be removed.
    * If the double dot has no parent path segment to work with, {@code null}
    * is returned.
    * <p>
    * The output will be the same on both Unix and Windows except
    * for the separator character.
    * <pre>
    * /foo//               -->   /foo
    * /foo/./              -->   /foo
    * /foo/../bar          -->   /bar
    * /foo/../bar/         -->   /bar
    * /foo/../bar/../baz   -->   /baz
    * //foo//./bar         -->   /foo/bar
    * /../                 -->   null
    * ../foo               -->   null
    * foo/bar/..           -->   foo
    * foo/../../bar        -->   null
    * foo/../bar           -->   bar
    * //server/foo/../bar  -->   //server/bar
    * //server/../bar      -->   null
    * C:\foo\..\bar        -->   C:\bar
    * C:\..\bar            -->   null
    * ~/foo/../bar/        -->   ~/bar
    * ~/../bar             -->   null
    * </pre>
    * (Note the file separator returned will be correct for Windows/Unix)
    *
    * @param filename  the filename to normalize, null returns null
    * @return the normalized filename, or null if invalid
    */
   public static String normalizeNoEndSeparator(String filename) {
       return doNormalize(filename, SYSTEM_SEPARATOR, false);
   }

   /**
    * 整理文件路径，使其“标准”化。比如去除重复多余的路径分隔符
    * Normalizes a path, removing double and single dot path steps,
    * and removing any final directory separator.
    * <p>
    * This method normalizes a path to a standard format.
    * The input may contain separators in either Unix or Windows format.
    * The output will contain separators in the format specified.
    * <p>
    * A trailing slash will be removed.
    * A double slash will be merged to a single slash (but UNC names are handled).
    * A single dot path segment will be removed.
    * A double dot will cause that path segment and the one before to be removed.
    * If the double dot has no parent path segment to work with, {@code null}
    * is returned.
    * <p>
    * The output will be the same on both Unix and Windows including
    * the separator character.
    * <pre>
    * /foo//               -->   /foo
    * /foo/./              -->   /foo
    * /foo/../bar          -->   /bar
    * /foo/../bar/         -->   /bar
    * /foo/../bar/../baz   -->   /baz
    * //foo//./bar         -->   /foo/bar
    * /../                 -->   null
    * ../foo               -->   null
    * foo/bar/..           -->   foo
    * foo/../../bar        -->   null
    * foo/../bar           -->   bar
    * //server/foo/../bar  -->   //server/bar
    * //server/../bar      -->   null
    * C:\foo\..\bar        -->   C:\bar
    * C:\..\bar            -->   null
    * ~/foo/../bar/        -->   ~/bar
    * ~/../bar             -->   null
    * </pre>
    *
    * @param filename  the filename to normalize, null returns null
    * @param unixSeparator {@code true} if a unix separator should
    * be used or {@code false} if a windows separtor should be used.
    * @return the normalized filename, or null if invalid
    * @since 2.0
    */
   public static String normalizeNoEndSeparator(String filename, boolean unixSeparator) {
        char separator = unixSeparator ? UNIX_SEPARATOR : WINDOWS_SEPARATOR;
       return doNormalize(filename, separator, false);
   }

   /**
    * 整理文件路径，使其“标准”化。比如去除重复多余的路径分隔符
    * Internal method to perform the normalization.
    *
    * @param filename  the filename
    * @param separator The separator character to use
    * @param keepSeparator  true to keep the final separator
    * @return the normalized filename
    */
   private static String doNormalize(String filename, char separator, boolean keepSeparator) {
       if (filename == null) {
           return null;
       }
       int size = filename.length();
       if (size == 0) {
           return filename;
       }
       int prefix = getPrefixLength(filename);
       if (prefix < 0) {
           return null;
       }
       
       char[] array = new char[size + 2];  // +1 for possible extra slash, +2 for arraycopy
       filename.getChars(0, filename.length(), array, 0);
       
       // fix separators throughout
       char otherSeparator = separator == SYSTEM_SEPARATOR ? OTHER_SEPARATOR : SYSTEM_SEPARATOR;
       for (int i = 0; i < array.length; i++) {
           if (array[i] == otherSeparator) {
               array[i] = separator;
           }
       }
       
       // add extra separator on the end to simplify code below
       boolean lastIsDirectory = true;
       if (array[size - 1] != separator) {
           array[size++] = separator;
           lastIsDirectory = false;
       }
       
       // adjoining slashes
       for (int i = prefix + 1; i < size; i++) {
           if (array[i] == separator && array[i - 1] == separator) {
               System.arraycopy(array, i, array, i - 1, size - i);
               size--;
               i--;
           }
       }
       
       // dot slash
       for (int i = prefix + 1; i < size; i++) {
           if (array[i] == separator && array[i - 1] == '.' &&
                   (i == prefix + 1 || array[i - 2] == separator)) {
               if (i == size - 1) {
                   lastIsDirectory = true;
               }
               System.arraycopy(array, i + 1, array, i - 1, size - i);
               size -=2;
               i--;
           }
       }
       
       // double dot slash
       outer:
       for (int i = prefix + 2; i < size; i++) {
           if (array[i] == separator && array[i - 1] == '.' && array[i - 2] == '.' &&
                   (i == prefix + 2 || array[i - 3] == separator)) {
               if (i == prefix + 2) {
                   return null;
               }
               if (i == size - 1) {
                   lastIsDirectory = true;
               }
               int j;
               for (j = i - 4 ; j >= prefix; j--) {
                   if (array[j] == separator) {
                       // remove b/../ from a/b/../c
                       System.arraycopy(array, i + 1, array, j + 1, size - i);
                       size -= i - j;
                       i = j + 1;
                       continue outer;
                   }
               }
               // remove a/../ from a/../c
               System.arraycopy(array, i + 1, array, prefix, size - i);
               size -= i + 1 - prefix;
               i = prefix + 1;
           }
       }
       
       if (size <= 0) {  // should never be less than 0
           return "";
       }
       if (size <= prefix) {  // should never be less than prefix
           return new String(array, 0, size);
       }
       if (lastIsDirectory && keepSeparator) {
           return new String(array, 0, size);  // keep trailing separator
       }
       return new String(array, 0, size - 1);  // lose trailing separator
   }

   //-----------------------------------------------------------------------
   /**
    * 组合生成完整文件路径
    * Concatenates a filename to a base path using normal command line style rules.
    * <p>
    * The effect is equivalent to resultant directory after changing
    * directory to the first argument, followed by changing directory to
    * the second argument.
    * <p>
    * The first argument is the base path, the second is the path to concatenate.
    * The returned path is always normalized via {@link #normalize(String)},
    * thus <code>..</code> is handled.
    * <p>
    * If <code>pathToAdd</code> is absolute (has an absolute prefix), then
    * it will be normalized and returned.
    * Otherwise, the paths will be joined, normalized and returned.
    * <p>
    * The output will be the same on both Unix and Windows except
    * for the separator character.
    * <pre>
    * /foo/ + bar          -->   /foo/bar
    * /foo + bar           -->   /foo/bar
    * /foo + /bar          -->   /bar
    * /foo + C:/bar        -->   C:/bar
    * /foo + C:bar         -->   C:bar (*)
    * /foo/a/ + ../bar     -->   foo/bar
    * /foo/ + ../../bar    -->   null
    * /foo/ + /bar         -->   /bar
    * /foo/.. + /bar       -->   /bar
    * /foo + bar/c.txt     -->   /foo/bar/c.txt
    * /foo/c.txt + bar     -->   /foo/c.txt/bar (!)
    * </pre>
    * (*) Note that the Windows relative drive prefix is unreliable when
    * used with this method.
    * (!) Note that the first parameter must be a path. If it ends with a name, then
    * the name will be built into the concatenated path. If this might be a problem,
    * use {@link #getFullPath(String)} on the base path argument.
    *
    * @param basePath  the base path to attach to, always treated as a path
    * @param fullFilenameToAdd  the filename (or path) to attach to the base
    * @return the concatenated path, or null if invalid
    */
   public static String concat(String basePath, String fullFilenameToAdd) {
       int prefix = getPrefixLength(fullFilenameToAdd);
       if (prefix < 0) {
           return null;
       }
       if (prefix > 0) {
           return normalize(fullFilenameToAdd);
       }
       if (basePath == null) {
           return null;
       }
       int len = basePath.length();
       if (len == 0) {
           return normalize(fullFilenameToAdd);
       }
       char ch = basePath.charAt(len - 1);
       if (isSeparator(ch)) {
           return normalize(basePath + fullFilenameToAdd);
       } else {
           return normalize(basePath + '/' + fullFilenameToAdd);
       }
   }

   /**
    * Determines whether the {@code parent} directory contains the {@code child} element (a file or directory).
    * <p>
    * The files names are expected to be normalized.
    * </p>
    * 
    * Edge cases:
    * <ul>
    * <li>A {@code directory} must not be null: if null, throw IllegalArgumentException</li>
    * <li>A directory does not contain itself: return false</li>
    * <li>A null child file is not contained in any parent: return false</li>
    * </ul>
    * 
    * @param canonicalParent
    *            the file to consider as the parent.
    * @param canonicalChild
    *            the file to consider as the child.
    * @return true is the candidate leaf is under by the specified composite. False otherwise.
    * @throws IOException
    *             if an IO error occurs while checking the files.
    * @since 2.2
    * @see FileUtils#directoryContains(File, File)
    */
   public static boolean directoryContains(final String canonicalParent, final String canonicalChild)
           throws IOException {

       // Fail fast against NullPointerException
       if (canonicalParent == null) {
           throw new IllegalArgumentException("Directory must not be null");
       }

       if (canonicalChild == null) {
           return false;
       }

       if (IOCase.SYSTEM.checkEquals(canonicalParent, canonicalChild)) {
           return false;
       }

       return IOCase.SYSTEM.checkStartsWith(canonicalChild, canonicalParent);
   }

   //-----------------------------------------------------------------------
   /**
    * 将Windows文件路径改为Unix文件路径
    * Converts all separators to the Unix separator of forward slash.
    * 
    * @param path  the path to be changed, null ignored
    * @return the updated path
    */
   public static String separatorsToUnix(String path) {
       if (path == null || path.indexOf(WINDOWS_SEPARATOR) == -1) {
           return path;
       }
       return path.replace(WINDOWS_SEPARATOR, UNIX_SEPARATOR);
   }

   /**
    * 将Unix文件路径改为Windows文件路径
    * Converts all separators to the Windows separator of backslash.
    * 
    * @param path  the path to be changed, null ignored
    * @return the updated path
    */
   public static String separatorsToWindows(String path) {
       if (path == null || path.indexOf(UNIX_SEPARATOR) == -1) {
           return path;
       }
       return path.replace(UNIX_SEPARATOR, WINDOWS_SEPARATOR);
   }

   /**
    * 改文件路径为当前系统文件路径
    * Converts all separators to the system separator.
    * 
    * @param path  the path to be changed, null ignored
    * @return the updated path
    */
   public static String separatorsToSystem(String path) {
       if (path == null) {
           return null;
       }
       if (isSystemWindows()) {
           return separatorsToWindows(path);
       } else {
           return separatorsToUnix(path);
       }
   }

   //-----------------------------------------------------------------------
   /**
    * Returns the length of the filename prefix, such as <code>C:/</code> or <code>~/</code>.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * <p>
    * The prefix length includes the first slash in the full filename
    * if applicable. Thus, it is possible that the length returned is greater
    * than the length of the input string.
    * <pre>
    * Windows:
    * a\b\c.txt           --> ""          --> relative
    * \a\b\c.txt          --> "\"         --> current drive absolute
    * C:a\b\c.txt         --> "C:"        --> drive relative
    * C:\a\b\c.txt        --> "C:\"       --> absolute
    * \\server\a\b\c.txt  --> "\\server\" --> UNC
    *
    * Unix:
    * a/b/c.txt           --> ""          --> relative
    * /a/b/c.txt          --> "/"         --> absolute
    * ~/a/b/c.txt         --> "~/"        --> current user
    * ~                   --> "~/"        --> current user (slash added)
    * ~user/a/b/c.txt     --> "~user/"    --> named user
    * ~user               --> "~user/"    --> named user (slash added)
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    * ie. both Unix and Windows prefixes are matched regardless.
    *
    * @param filename  the filename to find the prefix in, null returns -1
    * @return the length of the prefix, -1 if invalid or null
    */
   public static int getPrefixLength(String filename) {
       if (filename == null) {
           return -1;
       }
       int len = filename.length();
       if (len == 0) {
           return 0;
       }
       char ch0 = filename.charAt(0);
       if (ch0 == ':') {
           return -1;
       }
       if (len == 1) {
           if (ch0 == '~') {
               return 2;  // return a length greater than the input
           }
           return isSeparator(ch0) ? 1 : 0;
       } else {
           if (ch0 == '~') {
               int posUnix = filename.indexOf(UNIX_SEPARATOR, 1);
               int posWin = filename.indexOf(WINDOWS_SEPARATOR, 1);
               if (posUnix == -1 && posWin == -1) {
                   return len + 1;  // return a length greater than the input
               }
               posUnix = posUnix == -1 ? posWin : posUnix;
               posWin = posWin == -1 ? posUnix : posWin;
               return Math.min(posUnix, posWin) + 1;
           }
           char ch1 = filename.charAt(1);
           if (ch1 == ':') {
               ch0 = Character.toUpperCase(ch0);
               if (ch0 >= 'A' && ch0 <= 'Z') {
                   if (len == 2 || isSeparator(filename.charAt(2)) == false) {
                       return 2;
                   }
                   return 3;
               }
               return -1;
               
           } else if (isSeparator(ch0) && isSeparator(ch1)) {
               int posUnix = filename.indexOf(UNIX_SEPARATOR, 2);
               int posWin = filename.indexOf(WINDOWS_SEPARATOR, 2);
               if (posUnix == -1 && posWin == -1 || posUnix == 2 || posWin == 2) {
                   return -1;
               }
               posUnix = posUnix == -1 ? posWin : posUnix;
               posWin = posWin == -1 ? posUnix : posWin;
               return Math.min(posUnix, posWin) + 1;
           } else {
               return isSeparator(ch0) ? 1 : 0;
           }
       }
   }

   /**
    * Returns the index of the last directory separator character.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * The position of the last forward or backslash is returned.
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    * 
    * @param filename  the filename to find the last path separator in, null returns -1
    * @return the index of the last separator character, or -1 if there
    * is no such character
    */
   public static int indexOfLastSeparator(String filename) {
       if (filename == null) {
           return -1;
       }
       int lastUnixPos = filename.lastIndexOf(UNIX_SEPARATOR);
       int lastWindowsPos = filename.lastIndexOf(WINDOWS_SEPARATOR);
       return Math.max(lastUnixPos, lastWindowsPos);
   }

   /**
    * Returns the index of the last extension separator character, which is a dot.
    * <p>
    * This method also checks that there is no directory separator after the last dot.
    * To do this it uses {@link #indexOfLastSeparator(String)} which will
    * handle a file in either Unix or Windows format.
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    * 
    * @param filename  the filename to find the last path separator in, null returns -1
    * @return the index of the last separator character, or -1 if there
    * is no such character
    */
   public static int indexOfExtension(String filename) {
       if (filename == null) {
           return -1;
       }
       int extensionPos = filename.lastIndexOf(EXTENSION_SEPARATOR);
       int lastSeparator = indexOfLastSeparator(filename);
       return lastSeparator > extensionPos ? -1 : extensionPos;
   }

   //-----------------------------------------------------------------------
   /**
    * Gets the prefix from a full filename, such as <code>C:/</code>
    * or <code>~/</code>.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * The prefix includes the first slash in the full filename where applicable.
    * <pre>
    * Windows:
    * a\b\c.txt           --> ""          --> relative
    * \a\b\c.txt          --> "\"         --> current drive absolute
    * C:a\b\c.txt         --> "C:"        --> drive relative
    * C:\a\b\c.txt        --> "C:\"       --> absolute
    * \\server\a\b\c.txt  --> "\\server\" --> UNC
    *
    * Unix:
    * a/b/c.txt           --> ""          --> relative
    * /a/b/c.txt          --> "/"         --> absolute
    * ~/a/b/c.txt         --> "~/"        --> current user
    * ~                   --> "~/"        --> current user (slash added)
    * ~user/a/b/c.txt     --> "~user/"    --> named user
    * ~user               --> "~user/"    --> named user (slash added)
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    * ie. both Unix and Windows prefixes are matched regardless.
    *
    * @param filename  the filename to query, null returns null
    * @return the prefix of the file, null if invalid
    */
   public static String getPrefix(String filename) {
       if (filename == null) {
           return null;
       }
       int len = getPrefixLength(filename);
       if (len < 0) {
           return null;
       }
       if (len > filename.length()) {
           return filename + UNIX_SEPARATOR;  // we know this only happens for unix
       }
       return filename.substring(0, len);
   }

   /**
    * Gets the path from a full filename, which excludes the prefix.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * The method is entirely text based, and returns the text before and
    * including the last forward or backslash.
    * <pre>
    * C:\a\b\c.txt --> a\b\
    * ~/a/b/c.txt  --> a/b/
    * a.txt        --> ""
    * a/b/c        --> a/b/
    * a/b/c/       --> a/b/c/
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    * <p>
    * This method drops the prefix from the result.
    * See {@link #getFullPath(String)} for the method that retains the prefix.
    *
    * @param filename  the filename to query, null returns null
    * @return the path of the file, an empty string if none exists, null if invalid
    */
   public static String getPath(String filename) {
       return doGetPath(filename, 1);
   }

   /**
    * Gets the path from a full filename, which excludes the prefix, and
    * also excluding the final directory separator.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * The method is entirely text based, and returns the text before the
    * last forward or backslash.
    * <pre>
    * C:\a\b\c.txt --> a\b
    * ~/a/b/c.txt  --> a/b
    * a.txt        --> ""
    * a/b/c        --> a/b
    * a/b/c/       --> a/b/c
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    * <p>
    * This method drops the prefix from the result.
    * See {@link #getFullPathNoEndSeparator(String)} for the method that retains the prefix.
    *
    * @param filename  the filename to query, null returns null
    * @return the path of the file, an empty string if none exists, null if invalid
    */
   public static String getPathNoEndSeparator(String filename) {
       return doGetPath(filename, 0);
   }

   /**
    * Does the work of getting the path.
    * 
    * @param filename  the filename
    * @param separatorAdd  0 to omit the end separator, 1 to return it
    * @return the path
    */
   private static String doGetPath(String filename, int separatorAdd) {
       if (filename == null) {
           return null;
       }
       int prefix = getPrefixLength(filename);
       if (prefix < 0) {
           return null;
       }
       int index = indexOfLastSeparator(filename);
       int endIndex = index+separatorAdd;
       if (prefix >= filename.length() || index < 0 || prefix >= endIndex) {
           return "";
       }
       return filename.substring(prefix, endIndex);
   }

   /**
    * 获取文件所在路径的全路径
    * Gets the full path from a full filename, which is the prefix + path.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * The method is entirely text based, and returns the text before and
    * including the last forward or backslash.
    * <pre>
    * C:\a\b\c.txt --> C:\a\b\
    * ~/a/b/c.txt  --> ~/a/b/
    * a.txt        --> ""
    * a/b/c        --> a/b/
    * a/b/c/       --> a/b/c/
    * C:           --> C:
    * C:\          --> C:\
    * ~            --> ~/
    * ~/           --> ~/
    * ~user        --> ~user/
    * ~user/       --> ~user/
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    *
    * @param filename  the filename to query, null returns null
    * @return the path of the file, an empty string if none exists, null if invalid
    */
   public static String getFullPath(String filename) {
       return doGetFullPath(filename, true);
   }

   /**
    * 获取文件所在路径的全路径
    * Gets the full path from a full filename, which is the prefix + path,
    * and also excluding the final directory separator.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * The method is entirely text based, and returns the text before the
    * last forward or backslash.
    * <pre>
    * C:\a\b\c.txt --> C:\a\b
    * ~/a/b/c.txt  --> ~/a/b
    * a.txt        --> ""
    * a/b/c        --> a/b
    * a/b/c/       --> a/b/c
    * C:           --> C:
    * C:\          --> C:\
    * ~            --> ~
    * ~/           --> ~
    * ~user        --> ~user
    * ~user/       --> ~user
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    *
    * @param filename  the filename to query, null returns null
    * @return the path of the file, an empty string if none exists, null if invalid
    */
   public static String getFullPathNoEndSeparator(String filename) {
       return doGetFullPath(filename, false);
   }

   /**
    * Does the work of getting the path.
    * 
    * @param filename  the filename
    * @param includeSeparator  true to include the end separator
    * @return the path
    */
   private static String doGetFullPath(String filename, boolean includeSeparator) {
       if (filename == null) {
           return null;
       }
       int prefix = getPrefixLength(filename);
       if (prefix < 0) {
           return null;
       }
       if (prefix >= filename.length()) {
           if (includeSeparator) {
               return getPrefix(filename);  // add end slash if necessary
           } else {
               return filename;
           }
       }
       int index = indexOfLastSeparator(filename);
       if (index < 0) {
           return filename.substring(0, prefix);
       }
       int end = index + (includeSeparator ?  1 : 0);
       if (end == 0) {
           end++;
       }
       return filename.substring(0, end);
   }

   /**
    * 获取全文件名，包括扩展名
    * Gets the name minus the path from a full filename.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * The text after the last forward or backslash is returned.
    * <pre>
    * a/b/c.txt --> c.txt
    * a.txt     --> a.txt
    * a/b/c     --> c
    * a/b/c/    --> ""
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    *
    * @param filename  the filename to query, null returns null
    * @return the name of the file without the path, or an empty string if none exists
    */
   public static String getName(String filename) {
       if (filename == null) {
           return null;
       }
       int index = indexOfLastSeparator(filename);
       return filename.substring(index + 1);
   }

   /**
    * 获取文件名
    * Gets the base name, minus the full path and extension, from a full filename.
    * <p>
    * This method will handle a file in either Unix or Windows format.
    * The text after the last forward or backslash and before the last dot is returned.
    * <pre>
    * a/b/c.txt --> c
    * a.txt     --> a
    * a/b/c     --> c
    * a/b/c/    --> ""
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    *
    * @param filename  the filename to query, null returns null
    * @return the name of the file without the path, or an empty string if none exists
    */
   public static String getBaseName(String filename) {
       return removeExtension(getName(filename));
   }

   /**
    * 获取文件扩展名
    * Gets the extension of a filename.
    * <p>
    * This method returns the textual part of the filename after the last dot.
    * There must be no directory separator after the dot.
    * <pre>
    * foo.txt      --> "txt"
    * a/b/c.jpg    --> "jpg"
    * a/b.txt/c    --> ""
    * a/b/c        --> ""
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    *
    * @param filename the filename to retrieve the extension of.
    * @return the extension of the file or an empty string if none exists or {@code null}
    * if the filename is {@code null}.
    */
   public static String getExtension(String filename) {
       if (filename == null) {
           return null;
       }
       int index = indexOfExtension(filename);
       if (index == -1) {
           return "";
       } else {
           return filename.substring(index + 1);
       }
   }

   //-----------------------------------------------------------------------
   /**
    * Removes the extension from a filename.
    * <p>
    * This method returns the textual part of the filename before the last dot.
    * There must be no directory separator after the dot.
    * <pre>
    * foo.txt    --> foo
    * a\b\c.jpg  --> a\b\c
    * a\b\c      --> a\b\c
    * a.b\c      --> a.b\c
    * </pre>
    * <p>
    * The output will be the same irrespective of the machine that the code is running on.
    *
    * @param filename  the filename to query, null returns null
    * @return the filename minus the extension
    */
   public static String removeExtension(String filename) {
       if (filename == null) {
           return null;
       }
       int index = indexOfExtension(filename);
       if (index == -1) {
           return filename;
       } else {
           return filename.substring(0, index);
       }
   }

   //-----------------------------------------------------------------------
   /**
    * Checks whether two filenames are equal exactly.
    * <p>
    * No processing is performed on the filenames other than comparison,
    * thus this is merely a null-safe case-sensitive equals.
    *
    * @param filename1  the first filename to query, may be null
    * @param filename2  the second filename to query, may be null
    * @return true if the filenames are equal, null equals null
    * @see IOCase#SENSITIVE
    */
   public static boolean equals(String filename1, String filename2) {
       return equals(filename1, filename2, false, IOCase.SENSITIVE);
   }

   /**
    * Checks whether two filenames are equal using the case rules of the system.
    * <p>
    * No processing is performed on the filenames other than comparison.
    * The check is case-sensitive on Unix and case-insensitive on Windows.
    *
    * @param filename1  the first filename to query, may be null
    * @param filename2  the second filename to query, may be null
    * @return true if the filenames are equal, null equals null
    * @see IOCase#SYSTEM
    */
   public static boolean equalsOnSystem(String filename1, String filename2) {
       return equals(filename1, filename2, false, IOCase.SYSTEM);
   }

   //-----------------------------------------------------------------------
   /**
    * Checks whether two filenames are equal after both have been normalized.
    * <p>
    * Both filenames are first passed to {@link #normalize(String)}.
    * The check is then performed in a case-sensitive manner.
    *
    * @param filename1  the first filename to query, may be null
    * @param filename2  the second filename to query, may be null
    * @return true if the filenames are equal, null equals null
    * @see IOCase#SENSITIVE
    */
   public static boolean equalsNormalized(String filename1, String filename2) {
       return equals(filename1, filename2, true, IOCase.SENSITIVE);
   }

   /**
    * Checks whether two filenames are equal after both have been normalized
    * and using the case rules of the system.
    * <p>
    * Both filenames are first passed to {@link #normalize(String)}.
    * The check is then performed case-sensitive on Unix and
    * case-insensitive on Windows.
    *
    * @param filename1  the first filename to query, may be null
    * @param filename2  the second filename to query, may be null
    * @return true if the filenames are equal, null equals null
    * @see IOCase#SYSTEM
    */
   public static boolean equalsNormalizedOnSystem(String filename1, String filename2) {
       return equals(filename1, filename2, true, IOCase.SYSTEM);
   }

   /**
    * Checks whether two filenames are equal, optionally normalizing and providing
    * control over the case-sensitivity.
    *
    * @param filename1  the first filename to query, may be null
    * @param filename2  the second filename to query, may be null
    * @param normalized  whether to normalize the filenames
    * @param caseSensitivity  what case sensitivity rule to use, null means case-sensitive
    * @return true if the filenames are equal, null equals null
    * @since 1.3
    */
   public static boolean equals(
           String filename1, String filename2,
           boolean normalized, IOCase caseSensitivity) {
       
       if (filename1 == null || filename2 == null) {
           return filename1 == null && filename2 == null;
       }
       if (normalized) {
           filename1 = normalize(filename1);
           filename2 = normalize(filename2);
           if (filename1 == null || filename2 == null) {
               throw new NullPointerException(
                   "Error normalizing one or both of the file names");
           }
       }
       if (caseSensitivity == null) {
           caseSensitivity = IOCase.SENSITIVE;
       }
       return caseSensitivity.checkEquals(filename1, filename2);
   }

   //-----------------------------------------------------------------------
   /**
    * Checks whether the extension of the filename is that specified.
    * <p>
    * This method obtains the extension as the textual part of the filename
    * after the last dot. There must be no directory separator after the dot.
    * The extension check is case-sensitive on all platforms.
    *
    * @param filename  the filename to query, null returns false
    * @param extension  the extension to check for, null or empty checks for no extension
    * @return true if the filename has the specified extension
    */
   public static boolean isExtension(String filename, String extension) {
       if (filename == null) {
           return false;
       }
       if (extension == null || extension.length() == 0) {
           return indexOfExtension(filename) == -1;
       }
       String fileExt = getExtension(filename);
       return fileExt.equals(extension);
   }

   /**
    * Checks whether the extension of the filename is one of those specified.
    * <p>
    * This method obtains the extension as the textual part of the filename
    * after the last dot. There must be no directory separator after the dot.
    * The extension check is case-sensitive on all platforms.
    *
    * @param filename  the filename to query, null returns false
    * @param extensions  the extensions to check for, null checks for no extension
    * @return true if the filename is one of the extensions
    */
   public static boolean isExtension(String filename, String[] extensions) {
       if (filename == null) {
           return false;
       }
       if (extensions == null || extensions.length == 0) {
           return indexOfExtension(filename) == -1;
       }
       String fileExt = getExtension(filename);
       for (String extension : extensions) {
           if (fileExt.equals(extension)) {
               return true;
           }
       }
       return false;
   }

   /**
    * Checks whether the extension of the filename is one of those specified.
    * <p>
    * This method obtains the extension as the textual part of the filename
    * after the last dot. There must be no directory separator after the dot.
    * The extension check is case-sensitive on all platforms.
    *
    * @param filename  the filename to query, null returns false
    * @param extensions  the extensions to check for, null checks for no extension
    * @return true if the filename is one of the extensions
    */
   public static boolean isExtension(String filename, Collection<String> extensions) {
       if (filename == null) {
           return false;
       }
       if (extensions == null || extensions.isEmpty()) {
           return indexOfExtension(filename) == -1;
       }
       String fileExt = getExtension(filename);
       for (String extension : extensions) {
           if (fileExt.equals(extension)) {
               return true;
           }
       }
       return false;
   }

   //-----------------------------------------------------------------------
   /**
    * Checks a filename to see if it matches the specified wildcard matcher,
    * always testing case-sensitive.
    * <p>
    * The wildcard matcher uses the characters '?' and '*' to represent a
    * single or multiple (zero or more) wildcard characters.
    * This is the same as often found on Dos/Unix command lines.
    * The check is case-sensitive always.
    * <pre>
    * wildcardMatch("c.txt", "*.txt")      --> true
    * wildcardMatch("c.txt", "*.jpg")      --> false
    * wildcardMatch("a/b/c.txt", "a/b/*")  --> true
    * wildcardMatch("c.txt", "*.???")      --> true
    * wildcardMatch("c.txt", "*.????")     --> false
    * </pre>
    * N.B. the sequence "*?" does not work properly at present in match strings.
    * 
    * @param filename  the filename to match on
    * @param wildcardMatcher  the wildcard string to match against
    * @return true if the filename matches the wilcard string
    * @see IOCase#SENSITIVE
    */
   public static boolean wildcardMatch(String filename, String wildcardMatcher) {
       return wildcardMatch(filename, wildcardMatcher, IOCase.SENSITIVE);
   }

   /**
    * Checks a filename to see if it matches the specified wildcard matcher
    * using the case rules of the system.
    * <p>
    * The wildcard matcher uses the characters '?' and '*' to represent a
    * single or multiple (zero or more) wildcard characters.
    * This is the same as often found on Dos/Unix command lines.
    * The check is case-sensitive on Unix and case-insensitive on Windows.
    * <pre>
    * wildcardMatch("c.txt", "*.txt")      --> true
    * wildcardMatch("c.txt", "*.jpg")      --> false
    * wildcardMatch("a/b/c.txt", "a/b/*")  --> true
    * wildcardMatch("c.txt", "*.???")      --> true
    * wildcardMatch("c.txt", "*.????")     --> false
    * </pre>
    * N.B. the sequence "*?" does not work properly at present in match strings.
    * 
    * @param filename  the filename to match on
    * @param wildcardMatcher  the wildcard string to match against
    * @return true if the filename matches the wilcard string
    * @see IOCase#SYSTEM
    */
   public static boolean wildcardMatchOnSystem(String filename, String wildcardMatcher) {
       return wildcardMatch(filename, wildcardMatcher, IOCase.SYSTEM);
   }

   /**
    * Checks a filename to see if it matches the specified wildcard matcher
    * allowing control over case-sensitivity.
    * <p>
    * The wildcard matcher uses the characters '?' and '*' to represent a
    * single or multiple (zero or more) wildcard characters.
    * N.B. the sequence "*?" does not work properly at present in match strings.
    * 
    * @param filename  the filename to match on
    * @param wildcardMatcher  the wildcard string to match against
    * @param caseSensitivity  what case sensitivity rule to use, null means case-sensitive
    * @return true if the filename matches the wilcard string
    * @since 1.3
    */
   public static boolean wildcardMatch(String filename, String wildcardMatcher, IOCase caseSensitivity) {
       if (filename == null && wildcardMatcher == null) {
           return true;
       }
       if (filename == null || wildcardMatcher == null) {
           return false;
       }
       if (caseSensitivity == null) {
           caseSensitivity = IOCase.SENSITIVE;
       }
       String[] wcs = splitOnTokens(wildcardMatcher);
       boolean anyChars = false;
       int textIdx = 0;
       int wcsIdx = 0;
       Stack<int[]> backtrack = new Stack<int[]>();
       
       // loop around a backtrack stack, to handle complex * matching
       do {
           if (backtrack.size() > 0) {
               int[] array = backtrack.pop();
               wcsIdx = array[0];
               textIdx = array[1];
               anyChars = true;
           }
           
           // loop whilst tokens and text left to process
           while (wcsIdx < wcs.length) {
     
               if (wcs[wcsIdx].equals("?")) {
                   // ? so move to next text char
                   textIdx++;
                   if (textIdx > filename.length()) {
                       break;
                   }
                   anyChars = false;
                   
               } else if (wcs[wcsIdx].equals("*")) {
                   // set any chars status
                   anyChars = true;
                   if (wcsIdx == wcs.length - 1) {
                       textIdx = filename.length();
                   }
                   
               } else {
                   // matching text token
                   if (anyChars) {
                       // any chars then try to locate text token
                       textIdx = caseSensitivity.checkIndexOf(filename, textIdx, wcs[wcsIdx]);
                       if (textIdx == -1) {
                           // token not found
                           break;
                       }
                       int repeat = caseSensitivity.checkIndexOf(filename, textIdx + 1, wcs[wcsIdx]);
                       if (repeat >= 0) {
                           backtrack.push(new int[] {wcsIdx, repeat});
                       }
                   } else {
                       // matching from current position
                       if (!caseSensitivity.checkRegionMatches(filename, textIdx, wcs[wcsIdx])) {
                           // couldnt match token
                           break;
                       }
                   }
     
                   // matched text token, move text index to end of matched token
                   textIdx += wcs[wcsIdx].length();
                   anyChars = false;
               }
     
               wcsIdx++;
           }
           
           // full match
           if (wcsIdx == wcs.length && textIdx == filename.length()) {
               return true;
           }
           
       } while (backtrack.size() > 0);
 
       return false;
   }

   /**
    * Splits a string into a number of tokens.
    * The text is split by '?' and '*'.
    * Where multiple '*' occur consecutively they are collapsed into a single '*'.
    * 
    * @param text  the text to split
    * @return the array of tokens, never null
    */
   static String[] splitOnTokens(String text) {
       // used by wildcardMatch
       // package level so a unit test may run on this
       
       if (text.indexOf('?') == -1 && text.indexOf('*') == -1) {
           return new String[] { text };
       }

       char[] array = text.toCharArray();
       ArrayList<String> list = new ArrayList<String>();
       StringBuilder buffer = new StringBuilder();
       for (int i = 0; i < array.length; i++) {
           if (array[i] == '?' || array[i] == '*') {
               if (buffer.length() != 0) {
                   list.add(buffer.toString());
                   buffer.setLength(0);
               }
               if (array[i] == '?') {
                   list.add("?");
               } else if (list.isEmpty() ||
                       i > 0 && list.get(list.size() - 1).equals("*") == false) {
                   list.add("*");
               }
           } else {
               buffer.append(array[i]);
           }
       }
       if (buffer.length() != 0) {
           list.add(buffer.toString());
       }

       return list.toArray( new String[ list.size() ] );
   }

   private final static String infoPartSplit=".";
   private final static String infoMapSplit="_";
   private final static String infoApendSplit="..";
   
   /**
    * 将信息插入到文件名中
    * @param info
    * @param filename
    * @return
    */
   public static String saveInifo2FileName(Map<String,String> info,String filename){
	   if(info == null || info.size()<1 || StringTools.isBlank(filename)){
		   return filename;
	   }
	   StringBuffer sb = new StringBuffer();
	   for(Entry<String, String> item:info.entrySet()){
		   sb.append(item.getKey()+infoMapSplit+item.getValue()+infoPartSplit);
	   }
	   sb.replace(sb.length()-1, sb.length(), infoApendSplit);
	   sb.append(filename);
	   return sb.toString();
   }
   
   /**
    * 从文件名中提取信息，须结合 top.hmtools.io.FileNameTools.saveInifo2FileName(Map<String, String>, String) 配对使用
    * @param filename
    * @return
    */
   public static Map<String,String> getInfoFromFileName(String filename){
	   Map<String,String> result = new HashMap<String, String>();
	   if(StringTools.isBlank(filename)){
		   return result;
	   }
	   String[] mapsArr = filename.split("\\"+infoPartSplit);
	   for(String str:mapsArr){
		   int indexOfMapSplit = str.indexOf(infoMapSplit);
		   if(indexOfMapSplit<1){
			   continue;
		   }
		   String key = str.substring(0, indexOfMapSplit);
		   String value = str.substring(indexOfMapSplit+1);
		   result.put(key, value);
	   }
	   return result;
   }
   
   /**
    * 从加入信息后的文件名中提取原有文件名，须结合 top.hmtools.io.FileNameTools.saveInifo2FileName(Map<String, String>, String) 配对使用
    * @param filename
    * @return
    */
   public static String getOriginalNameByInfoName(String filename){
	   String result = filename;
	   if(StringTools.isBlank(filename)){
		   return result;
	   }
	   int indexOfSplit = filename.indexOf(infoApendSplit);
	   result=filename.substring(indexOfSplit+infoApendSplit.length());
	   return result;
   }
}

